# uncompyle6 version 3.2.3
# Python bytecode 3.6 (3379)
# Decompiled from: Python 3.6.8 |Anaconda custom (64-bit)| (default, Feb 21 2019, 18:30:04) [MSC v.1916 64 bit (AMD64)]
# Embedded file name: site-packages\sqlalchemy\orm\dependency.py
"""Relationship dependencies.

"""
from .. import sql, util, exc as sa_exc
from . import attributes, exc, sync, unitofwork, util as mapperutil
from .interfaces import ONETOMANY, MANYTOONE, MANYTOMANY


class DependencyProcessor(object):
    def __init__(self, prop):
        self.prop = prop
        self.cascade = prop.cascade
        self.mapper = prop.mapper
        self.parent = prop.parent
        self.secondary = prop.secondary
        self.direction = prop.direction
        self.post_update = prop.post_update
        self.passive_deletes = prop.passive_deletes
        self.passive_updates = prop.passive_updates
        self.enable_typechecks = prop.enable_typechecks
        if self.passive_deletes:
            self._passive_delete_flag = attributes.PASSIVE_NO_INITIALIZE
        else:
            self._passive_delete_flag = attributes.PASSIVE_OFF
        if self.passive_updates:
            self._passive_update_flag = attributes.PASSIVE_NO_INITIALIZE
        else:
            self._passive_update_flag = attributes.PASSIVE_OFF
        self.key = prop.key
        if not self.prop.synchronize_pairs:
            raise sa_exc.ArgumentError(
                "Can't build a DependencyProcessor for relationship %s. No target attributes to populate between parent and child are present"
                % self.prop
            )

    @classmethod
    def from_relationship(cls, prop):
        return _direction_to_processor[prop.direction](prop)

    def hasparent(self, state):
        """return True if the given object instance has a parent,
        according to the ``InstrumentedAttribute`` handled by this
        ``DependencyProcessor``.
        
        """
        return self.parent.class_manager.get_impl(self.key).hasparent(state)

    def per_property_preprocessors(self, uow):
        """establish actions and dependencies related to a flush.
        
        These actions will operate on all relevant states in
        the aggregate.
        
        """
        uow.register_preprocessor(self, True)

    def per_property_flush_actions(self, uow):
        after_save = unitofwork.ProcessAll(uow, self, False, True)
        before_delete = unitofwork.ProcessAll(uow, self, True, True)
        parent_saves = unitofwork.SaveUpdateAll(uow, self.parent.primary_base_mapper)
        child_saves = unitofwork.SaveUpdateAll(uow, self.mapper.primary_base_mapper)
        parent_deletes = unitofwork.DeleteAll(uow, self.parent.primary_base_mapper)
        child_deletes = unitofwork.DeleteAll(uow, self.mapper.primary_base_mapper)
        self.per_property_dependencies(
            uow,
            parent_saves,
            child_saves,
            parent_deletes,
            child_deletes,
            after_save,
            before_delete,
        )

    def per_state_flush_actions(self, uow, states, isdelete):
        """establish actions and dependencies related to a flush.
        
        These actions will operate on all relevant states
        individually.    This occurs only if there are cycles
        in the 'aggregated' version of events.
        
        """
        child_base_mapper = self.mapper.primary_base_mapper
        child_saves = unitofwork.SaveUpdateAll(uow, child_base_mapper)
        child_deletes = unitofwork.DeleteAll(uow, child_base_mapper)
        if isdelete:
            before_delete = unitofwork.ProcessAll(uow, self, True, True)
            before_delete.disabled = True
        else:
            after_save = unitofwork.ProcessAll(uow, self, False, True)
            after_save.disabled = True
        if child_saves not in uow.cycles:
            if not child_deletes not in uow.cycles:
                raise AssertionError
            child_actions = [(child_saves, False), (child_deletes, True)]
            child_in_cycles = False
        else:
            child_in_cycles = True
        if not isdelete:
            parent_saves = unitofwork.SaveUpdateAll(uow, self.parent.base_mapper)
            parent_deletes = before_delete = None
            if parent_saves in uow.cycles:
                parent_in_cycles = True
            else:
                parent_deletes = unitofwork.DeleteAll(uow, self.parent.base_mapper)
                parent_saves = after_save = None
                if parent_deletes in uow.cycles:
                    parent_in_cycles = True
            for state in states:
                sum_ = state.manager[self.key].impl.get_all_pending(
                    state,
                    state.dict,
                    self._passive_delete_flag
                    if isdelete
                    else attributes.PASSIVE_NO_INITIALIZE,
                )
                if not sum_:
                    continue
                    if isdelete:
                        before_delete = unitofwork.ProcessState(uow, self, True, state)
                        if parent_in_cycles:
                            parent_deletes = unitofwork.DeleteState(uow, state)
                        else:
                            after_save = unitofwork.ProcessState(
                                uow, self, False, state
                            )
                            if parent_in_cycles:
                                parent_saves = unitofwork.SaveUpdateState(uow, state)
                        if child_in_cycles:
                            child_actions = []
                            for child_state, child in sum_:
                                if child_state not in uow.states:
                                    child_action = (None, None)
                                else:
                                    deleted, listonly = uow.states[child_state]
                                    if deleted:
                                        child_action = (
                                            unitofwork.DeleteState(uow, child_state),
                                            True,
                                        )
                                    else:
                                        child_action = (
                                            unitofwork.SaveUpdateState(
                                                uow, child_state
                                            ),
                                            False,
                                        )
                                    child_actions.append(child_action)

                        for child_action, childisdelete in child_actions:
                            self.per_state_dependencies(
                                uow,
                                parent_saves,
                                parent_deletes,
                                child_action,
                                after_save,
                                before_delete,
                                isdelete,
                                childisdelete,
                            )

    def presort_deletes(self, uowcommit, states):
        return False

    def presort_saves(self, uowcommit, states):
        return False

    def process_deletes(self, uowcommit, states):
        pass

    def process_saves(self, uowcommit, states):
        pass

    def prop_has_changes(self, uowcommit, states, isdelete):
        if not isdelete or self.passive_deletes:
            passive = attributes.PASSIVE_NO_INITIALIZE
        else:
            if self.direction is MANYTOONE:
                passive = attributes.PASSIVE_NO_FETCH_RELATED
            else:
                passive = attributes.PASSIVE_OFF
            for s in states:
                history = uowcommit.get_attribute_history(s, self.key, passive)
                if history:
                    if not history.empty():
                        return True
            else:
                return (
                    states
                    and not self.prop._is_self_referential
                    and self.mapper in uowcommit.mappers
                )

    def _verify_canload(self, state):
        if self.prop.uselist:
            if state is None:
                raise exc.FlushError(
                    "Can't flush None value found in collection %s" % (self.prop,)
                )
            if state is not None:
                if not (
                    self.mapper._canload(
                        state, allow_subtypes=not self.enable_typechecks
                    )
                ):
                    if self.mapper._canload(state, allow_subtypes=True):
                        raise exc.FlushError(
                            'Attempting to flush an item of type %(x)s as a member of collection "%(y)s". Expected an object of type %(z)s or a polymorphic subclass of this type. If %(x)s is a subclass of %(z)s, configure mapper "%(zm)s" to load this subtype polymorphically, or set enable_typechecks=False to allow any subtype to be accepted for flush. '
                            % {
                                "x": state.class_,
                                "y": self.prop,
                                "z": self.mapper.class_,
                                "zm": self.mapper,
                            }
                        )
                    else:
                        raise exc.FlushError(
                            'Attempting to flush an item of type %(x)s as a member of collection "%(y)s". Expected an object of type %(z)s or a polymorphic subclass of this type.'
                            % {
                                "x": state.class_,
                                "y": self.prop,
                                "z": self.mapper.class_,
                            }
                        )

    def _synchronize(self, state, child, associationrow, clearkeys, uowcommit):
        raise NotImplementedError()

    def _get_reversed_processed_set(self, uow):
        if not self.prop._reverse_property:
            return
        else:
            process_key = tuple(
                sorted([self.key] + [p.key for p in self.prop._reverse_property])
            )
            return uow.memo(("reverse_key", process_key), set)

    def _post_update(self, state, uowcommit, related, is_m2o_delete=False):
        for x in related:
            if not is_m2o_delete or x is not None:
                uowcommit.register_post_update(
                    state, [r for l, r in self.prop.synchronize_pairs]
                )
                break

    def _pks_changed(self, uowcommit, state):
        raise NotImplementedError()

    def __repr__(self):
        return "%s(%s)" % (self.__class__.__name__, self.prop)


class OneToManyDP(DependencyProcessor):
    def per_property_dependencies(
        self,
        uow,
        parent_saves,
        child_saves,
        parent_deletes,
        child_deletes,
        after_save,
        before_delete,
    ):
        if self.post_update:
            child_post_updates = unitofwork.PostUpdateAll(
                uow, self.mapper.primary_base_mapper, False
            )
            child_pre_updates = unitofwork.PostUpdateAll(
                uow, self.mapper.primary_base_mapper, True
            )
            uow.dependencies.update(
                [
                    (child_saves, after_save),
                    (parent_saves, after_save),
                    (after_save, child_post_updates),
                    (before_delete, child_pre_updates),
                    (child_pre_updates, parent_deletes),
                    (child_pre_updates, child_deletes),
                ]
            )
        else:
            uow.dependencies.update(
                [
                    (parent_saves, after_save),
                    (after_save, child_saves),
                    (after_save, child_deletes),
                    (child_saves, parent_deletes),
                    (child_deletes, parent_deletes),
                    (before_delete, child_saves),
                    (before_delete, child_deletes),
                ]
            )

    def per_state_dependencies(
        self,
        uow,
        save_parent,
        delete_parent,
        child_action,
        after_save,
        before_delete,
        isdelete,
        childisdelete,
    ):
        if self.post_update:
            child_post_updates = unitofwork.PostUpdateAll(
                uow, self.mapper.primary_base_mapper, False
            )
            child_pre_updates = unitofwork.PostUpdateAll(
                uow, self.mapper.primary_base_mapper, True
            )
            if not isdelete:
                if childisdelete:
                    uow.dependencies.update(
                        [(child_action, after_save), (after_save, child_post_updates)]
                    )
                else:
                    uow.dependencies.update(
                        [
                            (save_parent, after_save),
                            (child_action, after_save),
                            (after_save, child_post_updates),
                        ]
                    )
            elif childisdelete:
                uow.dependencies.update(
                    [
                        (before_delete, child_pre_updates),
                        (child_pre_updates, delete_parent),
                    ]
                )
            else:
                uow.dependencies.update(
                    [
                        (before_delete, child_pre_updates),
                        (child_pre_updates, delete_parent),
                    ]
                )
        else:
            if not isdelete:
                uow.dependencies.update(
                    [
                        (save_parent, after_save),
                        (after_save, child_action),
                        (save_parent, child_action),
                    ]
                )
            else:
                uow.dependencies.update(
                    [(before_delete, child_action), (child_action, delete_parent)]
                )

    def presort_deletes(self, uowcommit, states):
        should_null_fks = not self.cascade.delete and not self.passive_deletes == "all"
        for state in states:
            history = uowcommit.get_attribute_history(
                state, self.key, self._passive_delete_flag
            )
            if history:
                for child in history.deleted:
                    if child is not None:
                        if self.hasparent(child) is False:
                            if self.cascade.delete_orphan:
                                uowcommit.register_object(child, isdelete=True)
                            else:
                                uowcommit.register_object(child)

                if should_null_fks:
                    for child in history.unchanged:
                        if child is not None:
                            uowcommit.register_object(
                                child, operation="delete", prop=self.prop
                            )

    def presort_saves(self, uowcommit, states):
        children_added = uowcommit.memo(("children_added", self), set)
        for state in states:
            pks_changed = self._pks_changed(uowcommit, state)
            if not pks_changed or self.passive_updates:
                passive = attributes.PASSIVE_NO_INITIALIZE
            else:
                passive = attributes.PASSIVE_OFF
            history = uowcommit.get_attribute_history(state, self.key, passive)
            if history:
                for child in history.added:
                    if child is not None:
                        uowcommit.register_object(
                            child, cancel_delete=True, operation="add", prop=self.prop
                        )

                children_added.update(history.added)
                for child in history.deleted:
                    if not self.cascade.delete_orphan:
                        uowcommit.register_object(
                            child, isdelete=False, operation="delete", prop=self.prop
                        )
                    elif self.hasparent(child) is False:
                        uowcommit.register_object(
                            child, isdelete=True, operation="delete", prop=self.prop
                        )
                        for c, m, st_, dct_ in self.mapper.cascade_iterator(
                            "delete", child
                        ):
                            uowcommit.register_object(st_, isdelete=True)

            if pks_changed:
                if history:
                    for child in history.unchanged:
                        if child is not None:
                            uowcommit.register_object(
                                child,
                                False,
                                self.passive_updates,
                                operation="pk change",
                                prop=self.prop,
                            )

    def process_deletes(self, uowcommit, states):
        if self.post_update or not self.passive_deletes == "all":
            children_added = uowcommit.memo(("children_added", self), set)
            for state in states:
                history = uowcommit.get_attribute_history(
                    state, self.key, self._passive_delete_flag
                )
                if history:
                    for child in history.deleted:
                        if child is not None:
                            if self.hasparent(child) is False:
                                self._synchronize(
                                    state, child, None, True, uowcommit, False
                                )
                                if self.post_update:
                                    if child:
                                        self._post_update(child, uowcommit, [state])

                    if self.post_update or not self.cascade.delete:
                        for child in set(history.unchanged).difference(children_added):
                            if child is not None:
                                self._synchronize(
                                    state, child, None, True, uowcommit, False
                                )
                                if self.post_update:
                                    if child:
                                        self._post_update(child, uowcommit, [state])

    def process_saves(self, uowcommit, states):
        for state in states:
            history = uowcommit.get_attribute_history(
                state, self.key, attributes.PASSIVE_NO_INITIALIZE
            )
            if history:
                for child in history.added:
                    self._synchronize(state, child, None, False, uowcommit, False)
                    if child is not None:
                        if self.post_update:
                            self._post_update(child, uowcommit, [state])

                for child in history.deleted:
                    if not self.cascade.delete_orphan:
                        if not self.hasparent(child):
                            self._synchronize(
                                state, child, None, True, uowcommit, False
                            )

                if self._pks_changed(uowcommit, state):
                    for child in history.unchanged:
                        self._synchronize(state, child, None, False, uowcommit, True)

    def _synchronize(
        self, state, child, associationrow, clearkeys, uowcommit, pks_changed
    ):
        source = state
        dest = child
        self._verify_canload(child)
        if dest is None or not self.post_update and uowcommit.is_deleted(dest):
            return
        if clearkeys:
            sync.clear(dest, self.mapper, self.prop.synchronize_pairs)
        else:
            sync.populate(
                source,
                self.parent,
                dest,
                self.mapper,
                self.prop.synchronize_pairs,
                uowcommit,
                self.passive_updates and pks_changed,
            )

    def _pks_changed(self, uowcommit, state):
        return sync.source_modified(
            uowcommit, state, self.parent, self.prop.synchronize_pairs
        )


class ManyToOneDP(DependencyProcessor):
    def __init__(self, prop):
        DependencyProcessor.__init__(self, prop)
        self.mapper._dependency_processors.append(DetectKeySwitch(prop))

    def per_property_dependencies(
        self,
        uow,
        parent_saves,
        child_saves,
        parent_deletes,
        child_deletes,
        after_save,
        before_delete,
    ):
        if self.post_update:
            parent_post_updates = unitofwork.PostUpdateAll(
                uow, self.parent.primary_base_mapper, False
            )
            parent_pre_updates = unitofwork.PostUpdateAll(
                uow, self.parent.primary_base_mapper, True
            )
            uow.dependencies.update(
                [
                    (child_saves, after_save),
                    (parent_saves, after_save),
                    (after_save, parent_post_updates),
                    (after_save, parent_pre_updates),
                    (before_delete, parent_pre_updates),
                    (parent_pre_updates, child_deletes),
                ]
            )
        else:
            uow.dependencies.update(
                [
                    (child_saves, after_save),
                    (after_save, parent_saves),
                    (parent_saves, child_deletes),
                    (parent_deletes, child_deletes),
                ]
            )

    def per_state_dependencies(
        self,
        uow,
        save_parent,
        delete_parent,
        child_action,
        after_save,
        before_delete,
        isdelete,
        childisdelete,
    ):
        if self.post_update:
            if not isdelete:
                parent_post_updates = unitofwork.PostUpdateAll(
                    uow, self.parent.primary_base_mapper, False
                )
                if childisdelete:
                    uow.dependencies.update(
                        [
                            (after_save, parent_post_updates),
                            (parent_post_updates, child_action),
                        ]
                    )
                else:
                    uow.dependencies.update(
                        [
                            (save_parent, after_save),
                            (child_action, after_save),
                            (after_save, parent_post_updates),
                        ]
                    )
            else:
                parent_pre_updates = unitofwork.PostUpdateAll(
                    uow, self.parent.primary_base_mapper, True
                )
                uow.dependencies.update(
                    [
                        (before_delete, parent_pre_updates),
                        (parent_pre_updates, delete_parent),
                        (parent_pre_updates, child_action),
                    ]
                )
        else:
            if not isdelete:
                if not childisdelete:
                    uow.dependencies.update(
                        [(child_action, after_save), (after_save, save_parent)]
                    )
                else:
                    uow.dependencies.update([(after_save, save_parent)])
            else:
                if childisdelete:
                    uow.dependencies.update([(delete_parent, child_action)])

    def presort_deletes(self, uowcommit, states):
        if self.cascade.delete or self.cascade.delete_orphan:
            for state in states:
                history = uowcommit.get_attribute_history(
                    state, self.key, self._passive_delete_flag
                )
                if history:
                    if self.cascade.delete_orphan:
                        todelete = history.sum()
                    else:
                        todelete = history.non_deleted()
                    for child in todelete:
                        if child is None:
                            continue
                        uowcommit.register_object(
                            child, isdelete=True, operation="delete", prop=self.prop
                        )
                        t = self.mapper.cascade_iterator("delete", child)
                        for c, m, st_, dct_ in t:
                            uowcommit.register_object(st_, isdelete=True)

    def presort_saves(self, uowcommit, states):
        for state in states:
            uowcommit.register_object(state, operation="add", prop=self.prop)
            if self.cascade.delete_orphan:
                history = uowcommit.get_attribute_history(
                    state, self.key, self._passive_delete_flag
                )
                if history:
                    for child in history.deleted:
                        if self.hasparent(child) is False:
                            uowcommit.register_object(
                                child, isdelete=True, operation="delete", prop=self.prop
                            )
                            t = self.mapper.cascade_iterator("delete", child)
                            for c, m, st_, dct_ in t:
                                uowcommit.register_object(st_, isdelete=True)

    def process_deletes(self, uowcommit, states):
        if self.post_update:
            if not self.cascade.delete_orphan:
                if not self.passive_deletes == "all":
                    for state in states:
                        self._synchronize(state, None, None, True, uowcommit)
                        if state:
                            if self.post_update:
                                history = uowcommit.get_attribute_history(
                                    state, self.key, self._passive_delete_flag
                                )
                                if history:
                                    self._post_update(
                                        state,
                                        uowcommit,
                                        history.sum(),
                                        is_m2o_delete=True,
                                    )

    def process_saves(self, uowcommit, states):
        for state in states:
            history = uowcommit.get_attribute_history(
                state, self.key, attributes.PASSIVE_NO_INITIALIZE
            )
            if history:
                if history.added:
                    for child in history.added:
                        self._synchronize(state, child, None, False, uowcommit, "add")

                if self.post_update:
                    self._post_update(state, uowcommit, history.sum())

    def _synchronize(
        self, state, child, associationrow, clearkeys, uowcommit, operation=None
    ):
        if state is None or not self.post_update and uowcommit.is_deleted(state):
            return
        if operation is not None:
            if child is not None:
                if not uowcommit.session._contains_state(child):
                    util.warn(
                        "Object of type %s not in session, %s operation along '%s' won't proceed"
                        % (mapperutil.state_class_str(child), operation, self.prop)
                    )
                    return
                if clearkeys or child is None:
                    sync.clear(state, self.parent, self.prop.synchronize_pairs)
                else:
                    self._verify_canload(child)
                    sync.populate(
                        child,
                        self.mapper,
                        state,
                        self.parent,
                        self.prop.synchronize_pairs,
                        uowcommit,
                        False,
                    )


class DetectKeySwitch(DependencyProcessor):
    """For many-to-one relationships with no one-to-many backref,
    searches for parents through the unit of work when a primary
    key has changed and updates them.
    
    Theoretically, this approach could be expanded to support transparent
    deletion of objects referenced via many-to-one as well, although
    the current attribute system doesn't do enough bookkeeping for this
    to be efficient.
    
    """

    def per_property_preprocessors(self, uow):
        if self.prop._reverse_property:
            if self.passive_updates:
                return
            if False in (prop.passive_updates for prop in self.prop._reverse_property):
                return
            uow.register_preprocessor(self, False)

    def per_property_flush_actions(self, uow):
        parent_saves = unitofwork.SaveUpdateAll(uow, self.parent.base_mapper)
        after_save = unitofwork.ProcessAll(uow, self, False, False)
        uow.dependencies.update([(parent_saves, after_save)])

    def per_state_flush_actions(self, uow, states, isdelete):
        pass

    def presort_deletes(self, uowcommit, states):
        pass

    def presort_saves(self, uow, states):
        if not self.passive_updates:
            self._process_key_switches(states, uow)

    def prop_has_changes(self, uow, states, isdelete):
        if not isdelete:
            if self.passive_updates:
                d = self._key_switchers(uow, states)
                return bool(d)
            return False

    def process_deletes(self, uowcommit, states):
        if not False:
            raise AssertionError

    def process_saves(self, uowcommit, states):
        if not self.passive_updates:
            raise AssertionError
        self._process_key_switches(states, uowcommit)

    def _key_switchers(self, uow, states):
        switched, notswitched = uow.memo(("pk_switchers", self), lambda: (set(), set()))
        allstates = switched.union(notswitched)
        for s in states:
            if s not in allstates:
                if self._pks_changed(uow, s):
                    switched.add(s)
                else:
                    notswitched.add(s)

        return switched

    def _process_key_switches(self, deplist, uowcommit):
        switchers = self._key_switchers(uowcommit, deplist)
        if switchers:
            for state in uowcommit.session.identity_map.all_states():
                if not issubclass(state.class_, self.parent.class_):
                    continue
                dict_ = state.dict
                related = state.get_impl(self.key).get(
                    state, dict_, passive=self._passive_update_flag
                )
                if related is not attributes.PASSIVE_NO_RESULT:
                    if related is not None:
                        related_state = attributes.instance_state(dict_[self.key])
                        if related_state in switchers:
                            uowcommit.register_object(
                                state, False, self.passive_updates
                            )
                            sync.populate(
                                related_state,
                                self.mapper,
                                state,
                                self.parent,
                                self.prop.synchronize_pairs,
                                uowcommit,
                                self.passive_updates,
                            )

    def _pks_changed(self, uowcommit, state):
        return bool(state.key) and sync.source_modified(
            uowcommit, state, self.mapper, self.prop.synchronize_pairs
        )


class ManyToManyDP(DependencyProcessor):
    def per_property_dependencies(
        self,
        uow,
        parent_saves,
        child_saves,
        parent_deletes,
        child_deletes,
        after_save,
        before_delete,
    ):
        uow.dependencies.update(
            [
                (parent_saves, after_save),
                (child_saves, after_save),
                (after_save, child_deletes),
                (before_delete, parent_saves),
                (before_delete, parent_deletes),
                (before_delete, child_deletes),
                (before_delete, child_saves),
            ]
        )

    def per_state_dependencies(
        self,
        uow,
        save_parent,
        delete_parent,
        child_action,
        after_save,
        before_delete,
        isdelete,
        childisdelete,
    ):
        if not isdelete:
            if childisdelete:
                uow.dependencies.update(
                    [(save_parent, after_save), (after_save, child_action)]
                )
            else:
                uow.dependencies.update(
                    [(save_parent, after_save), (child_action, after_save)]
                )
        else:
            uow.dependencies.update(
                [(before_delete, child_action), (before_delete, delete_parent)]
            )

    def presort_deletes(self, uowcommit, states):
        if not self.passive_deletes:
            for state in states:
                uowcommit.get_attribute_history(
                    state, self.key, self._passive_delete_flag
                )

    def presort_saves(self, uowcommit, states):
        if not self.passive_updates:
            for state in states:
                if self._pks_changed(uowcommit, state):
                    history = uowcommit.get_attribute_history(
                        state, self.key, attributes.PASSIVE_OFF
                    )

        if not self.cascade.delete_orphan:
            return
        for state in states:
            history = uowcommit.get_attribute_history(
                state, self.key, attributes.PASSIVE_NO_INITIALIZE
            )
            if history:
                for child in history.deleted:
                    if self.hasparent(child) is False:
                        uowcommit.register_object(
                            child, isdelete=True, operation="delete", prop=self.prop
                        )
                        for c, m, st_, dct_ in self.mapper.cascade_iterator(
                            "delete", child
                        ):
                            uowcommit.register_object(st_, isdelete=True)

    def process_deletes(self, uowcommit, states):
        secondary_delete = []
        secondary_insert = []
        secondary_update = []
        processed = self._get_reversed_processed_set(uowcommit)
        tmp = set()
        for state in states:
            history = uowcommit.get_attribute_history(
                state, self.key, self._passive_delete_flag
            )
            if history:
                for child in history.non_added():
                    if not child is None:
                        if processed is not None:
                            if (state, child) in processed:
                                continue
                            associationrow = {}
                            if not self._synchronize(
                                state, child, associationrow, False, uowcommit, "delete"
                            ):
                                pass
                        else:
                            secondary_delete.append(associationrow)

                tmp.update(((c, state) for c in history.non_added()))

        if processed is not None:
            processed.update(tmp)
        self._run_crud(uowcommit, secondary_insert, secondary_update, secondary_delete)

    def process_saves(self, uowcommit, states):
        secondary_delete = []
        secondary_insert = []
        secondary_update = []
        processed = self._get_reversed_processed_set(uowcommit)
        tmp = set()
        for state in states:
            need_cascade_pks = not self.passive_updates and self._pks_changed(
                uowcommit, state
            )
            if need_cascade_pks:
                passive = attributes.PASSIVE_OFF
            else:
                passive = attributes.PASSIVE_NO_INITIALIZE
            history = uowcommit.get_attribute_history(state, self.key, passive)
            if history:
                for child in history.added:
                    if processed is not None:
                        if (state, child) in processed:
                            continue
                        associationrow = {}
                        if not self._synchronize(
                            state, child, associationrow, False, uowcommit, "add"
                        ):
                            pass
                        else:
                            secondary_insert.append(associationrow)

                for child in history.deleted:
                    if processed is not None:
                        if (state, child) in processed:
                            continue
                        associationrow = {}
                        if not self._synchronize(
                            state, child, associationrow, False, uowcommit, "delete"
                        ):
                            pass
                        else:
                            secondary_delete.append(associationrow)

                tmp.update(((c, state) for c in history.added + history.deleted))
                if need_cascade_pks:
                    for child in history.unchanged:
                        associationrow = {}
                        sync.update(
                            state,
                            self.parent,
                            associationrow,
                            "old_",
                            self.prop.synchronize_pairs,
                        )
                        sync.update(
                            child,
                            self.mapper,
                            associationrow,
                            "old_",
                            self.prop.secondary_synchronize_pairs,
                        )
                        secondary_update.append(associationrow)

        if processed is not None:
            processed.update(tmp)
        self._run_crud(uowcommit, secondary_insert, secondary_update, secondary_delete)

    def _run_crud(
        self, uowcommit, secondary_insert, secondary_update, secondary_delete
    ):
        connection = uowcommit.transaction.connection(self.mapper)
        if secondary_delete:
            associationrow = secondary_delete[0]
            statement = self.secondary.delete(
                sql.and_(
                    *[
                        c == (sql.bindparam(c.key, type_=c.type))
                        for c in self.secondary.c
                        if c.key in associationrow
                    ]
                )
            )
            result = connection.execute(statement, secondary_delete)
            if result.supports_sane_multi_rowcount():
                if result.rowcount != len(secondary_delete):
                    raise exc.StaleDataError(
                        "DELETE statement on table '%s' expected to delete %d row(s); Only %d were matched."
                        % (
                            self.secondary.description,
                            len(secondary_delete),
                            result.rowcount,
                        )
                    )
        if secondary_update:
            associationrow = secondary_update[0]
            statement = self.secondary.update(
                sql.and_(
                    *[
                        c == (sql.bindparam("old_" + c.key, type_=c.type))
                        for c in self.secondary.c
                        if c.key in associationrow
                    ]
                )
            )
            result = connection.execute(statement, secondary_update)
            if result.supports_sane_multi_rowcount():
                if result.rowcount != len(secondary_update):
                    raise exc.StaleDataError(
                        "UPDATE statement on table '%s' expected to update %d row(s); Only %d were matched."
                        % (
                            self.secondary.description,
                            len(secondary_update),
                            result.rowcount,
                        )
                    )
        if secondary_insert:
            statement = self.secondary.insert()
            connection.execute(statement, secondary_insert)

    def _synchronize(
        self, state, child, associationrow, clearkeys, uowcommit, operation
    ):
        self._verify_canload(child)
        if child is None:
            return False
        else:
            if child is not None:
                if not uowcommit.session._contains_state(child):
                    if not child.deleted:
                        util.warn(
                            "Object of type %s not in session, %s operation along '%s' won't proceed"
                            % (mapperutil.state_class_str(child), operation, self.prop)
                        )
                    return False
                sync.populate_dict(
                    state, self.parent, associationrow, self.prop.synchronize_pairs
                )
                sync.populate_dict(
                    child,
                    self.mapper,
                    associationrow,
                    self.prop.secondary_synchronize_pairs,
                )
            return True

    def _pks_changed(self, uowcommit, state):
        return sync.source_modified(
            uowcommit, state, self.parent, self.prop.synchronize_pairs
        )


_direction_to_processor = {
    ONETOMANY: OneToManyDP,
    MANYTOONE: ManyToOneDP,
    MANYTOMANY: ManyToManyDP,
}
